{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python前十周学习总结\n",
    ">> 总结方式：以字典形式进行知识点整理与归纳"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 课程学习目标\n",
    "- 应用编程及程序开发通用技能。  \n",
    "- 运用Python 语言来实践网站与移动应用开发。  \n",
    "- 找寻、评估并使用Python 语言编程库及工具。  \n",
    "- 加入并参与Python 语言项目开发。  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 课程学习介绍"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python语言"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_introduce={\n",
    "    \"官网\":\"Python官网：https://www.python.org/\",\n",
    "    \"简介\":{\"python的创始人为吉多·范罗苏姆（Guido van Rossum）1989年的圣诞节期间，吉多·范罗苏姆为了在阿姆斯特丹打发时间，决心开发一个新的脚本解释程序，作为ABC语言的一种继承\",\n",
    "            \"Python是一种跨平台的计算机程序设计语言。 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。\",\n",
    "            \"最新的TIOBE排行榜(https://www.tiobe.com/tiobe-index/)显示，Python赶超C++占据第3， Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言。\"},\n",
    "    \"定义\":{\"Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言\",\n",
    "            \"Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。\",\n",
    "            \"Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。\",\n",
    "            \"Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。  \",\n",
    "            \"Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。 \",\n",
    "            \"Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。\"}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python应用基础"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_base={\n",
    "       \"IDE\":{ \n",
    "           \"advantage\":{\"1.节省时间和精力。IDE的目的就是要让开发更加快捷方便，通过提供工具和各种性能来帮助开发者组织资源，减少失误，提供捷径。\",\n",
    "                        \"2.建立统一标准。当一组程序员使用同一个开发环境时，就建立了统一的工作标准，当IDE提供预设的模板，或者不同团队分享代码库时，这一效果就更加明显了。\",\n",
    "                        \"3.管理开发工作。首先，IDE提供文档工具，可以自动输入开发者评论，或者迫使开发者在不同区域编写评论。其次，IDE可以展示资源，更便于发现应用所处位置，无需在文件系统里面艰难的搜索。\"},\n",
    "            \"disadvantage\":{\"1.学习曲线问题。IDE基本上是比较复杂的工具，为了更好的熟练使用，需要一定的时间和耐心。\",\n",
    "                            \"2.初学者的困难。对初学者来说，使用IDE来学习开发有相当的难度，不适合学习一种新语言时使用。\",\n",
    "                            \"3.无法修复坏代码或设计。开发者不能完全依赖工具的便捷，还是必须保持专业水准和熟练度，开发的成果好坏主要还是看开发员的技术。\"},\n",
    "            \"IDLE\":{\"掌握程度：90\",\n",
    "                    \"含义简介：是Python的集成开发环境\"},\n",
    "            \"JUPYTE\":{\"掌握程度：90\",\n",
    "                      \"含义简介：本质是一个 Web 应用程序，便于创建和共享文学化程序文档，支持实时代码，数学方程，可视化和 markdown。\",\"用途：数据清理和转换，数值模拟，统计建模，机器学习等等\"},\n",
    "            \"pycharm\":{\"掌握程度：90\",\n",
    "                       \"含义简介：带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，比如调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制。此外，该IDE提供了一些高级功能，以用于支持Django框架下的专业Web开发。\"}\n",
    "                     }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python语法学习"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IF 语句"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_if={\n",
    "    'IF':{\n",
    "        \"掌握程度\":\"80\",\n",
    "           \"未掌握原因\":\"对python逻辑掌握不够灵活，不能准确将题目要求转换为if语句里的具体条件\",\n",
    "           \"if简介\":\"是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。\",\n",
    "                    \"代码实例\":{\"from datetime import datetime\",\n",
    "                                \"odds = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59 ]\",\n",
    "                                \"right_this_minute = datetime.today().minute\",\n",
    "                                \"if right_this_minute in odds:\",\n",
    "                                \"print('This minute seems a little odd.')\",\n",
    "                                \"else:\" ,\n",
    "                                \"print('Not an odd minute.')\"},\n",
    "                     \"注意事项\":\"可以进行嵌套。 不要超过3层， 最多5层\",\n",
    "                     '参考网页':'https://www.runoob.com/python/python-if-statement.html'\n",
    "          }}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 循环语句"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### for循环\n",
    "#### while循环  \n",
    "#### 内置函数range  \n",
    "#### Break语句  \n",
    "#### continue语句  \n",
    "#### pass语句  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_loop={'参考网页':'https://www.runoob.com/python/python-loops.html',\n",
    "             '掌握程度分析':'整体掌握程度均较低，因为感觉于个人而言，练习较少，逻辑训练不够，不能熟练将题目要求迅速转换成为python语言',\n",
    "             \n",
    "             'For':{'掌握程度':'75',\n",
    "                    '定义':'重复执行语句',\n",
    "                    '代码示例':{\n",
    "                        \"for letter in 'Python': \",\n",
    "                        \" print '当前字母 :', letter\",\n",
    "                        \"fruits = ['banana', 'apple',  'mango']\"},\n",
    "                    \n",
    "            'While':{'掌握程度':'75',\n",
    "                     '定义':'在给定的判断条件为 true 时执行循环体，否则退出循环体。',\n",
    "                     '代码示例':{\n",
    "                          'var = 1',\n",
    "                          'while var == 1 :  # 该条件永远为true，循环将无限执行下去',\n",
    "                          'num = raw_input(\"Enter a number  :\")',\n",
    "                          'print \"You entered: \", num',\n",
    "                          'print \"Good bye!\"'}\n",
    "                     },\n",
    "                    \n",
    "            '内置函数range':{'掌握程度':'65',\n",
    "                             '代码实例':{\n",
    "                                 'range(5)',\n",
    "                                 'list(range(5))',\n",
    "                                 'list(range(5,10))',\n",
    "                                 'list(range(0,10,2))',\n",
    "                                 'list(range(10,0,-2))',\n",
    "                                 'list(range(99,0,-1))'}\n",
    "                            },\n",
    "            'Break':{'掌握程度':'80',\n",
    "                     '定义及注意事项':{'break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。',\n",
    "                                       'break语句用在while和for循环中。',\n",
    "                                       '如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。'},\n",
    "                     '代码实例':{\"for letter in 'Python':\",\n",
    "                                 \"if letter == 'h':\",\n",
    "                                 \"break\",\n",
    "                                 \"print '当前字母 :', letter'\"}\n",
    "                               },\n",
    "            'Continue':{'掌握程度':'80',\n",
    "                        '与break的区别':'continue 语句跳出本次循环，而break跳出整个循环。',\n",
    "                        '定义':{'continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。',\n",
    "                                'continue语句用在while和for循环中。'},\n",
    "                        '代码实例':{\"for letter in 'Python':\",\n",
    "                                    \"if letter == 'h':\",\n",
    "                                    \"continue\",\n",
    "                                    \"print '当前字母 :', letter'\"},\n",
    "             'Pass':{'掌握程度':'80',\n",
    "                     '定义':{'Python pass 是空语句，是为了保持程序结构的完整性。',\n",
    "                             'pass 不做任何事情，一般用做占位语句。'},\n",
    "                     '代码示例':{\"for letter in 'Python':\",\n",
    "                                 \"if letter == 'h':\",\n",
    "                                 \"pass\",\n",
    "                                 \"print '这是 pass 块'\",\n",
    "                                 \"print '当前字母 :', letter\",\n",
    "                                 'print \"Good bye!\"'},\n",
    "                     '妙用':'当你没有想好函数的内容是可以用 pass 填充，使程序可以正常运行。'\n",
    "                    }\n",
    "                       }\n",
    "                   }\n",
    "            }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 变量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 数字"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_number={\n",
    "                '掌握程度':'75',\n",
    "                '参考网页':'https://www.runoob.com/python/python-numbers.html',\n",
    "                '定义':'数据类型用于存储数值。',\n",
    "                '注意事项':'数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。',\n",
    "                '四种不同的数值类型':['整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点',\n",
    "                                      '长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。',\n",
    "                                      '浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）',\n",
    "                                      '复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。'],\n",
    "     '类型转换':{\n",
    "                 'int(x [,base ])':'将x转换为一个整数 ',\n",
    "                 'long(x [,base ])':'将x转换为一个长整数',  \n",
    "                 'float(x )':'将x转换到一个浮点数', \n",
    "                 'complex(real [,imag ])':'创建一个复数',\n",
    "                 'str(x )':'将对象 x 转换为字符串',\n",
    "                 'repr(x )':'将对象 x 转换为表达式字符串',\n",
    "                 'eval(str )':'用来计算在字符串中的有效Python表达式,并返回一个对象',\n",
    "                 'tuple(s )':'将序列 s 转换为一个元组',\n",
    "                 'list(s )':'将序列 s 转换为一个列表',\n",
    "                 'chr(x )':'将一个整数转换为一个字符',\n",
    "                 'unichr(x )':'将一个整数转换为Unicode字符',\n",
    "                 'ord(x )':'将一个字符转换为它的整数值',\n",
    "                 'hex(x )':'将一个整数转换为一个十六进制字符串', \n",
    "                 'oct(x )':'将一个整数转换为一个八进制字符串'},\n",
    "     'random模块':{\n",
    "                '掌握程度':'75',\n",
    "                '定义':'返回随机生成的一个实数，它在[0,1)范围内。',\n",
    "                '注意事项':'random()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。',\n",
    "                '代码示例':['import random',\n",
    "                    'print \"random() : \", random.random()',\n",
    "                    'print \"random() : \", random.random()'],\n",
    "                '参考网页':'https://www.runoob.com/python/func-number-random.html'}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_str={\n",
    "            '掌握程度':'75',\n",
    "            '参考网页':'https://www.runoob.com/python/python-strings.html',\n",
    "            '定义':'Python 中最常用的数据类型。我们可以使用引号(\"'\"或'\"')来创建字符串。',\n",
    "            '常见转义字符':{\n",
    "                           '\\ -----> (在行尾时)续行符',\n",
    "                           '\\\\ -----> 反斜杠符号'\n",
    "                           \"\\' -----> 单引号\"\n",
    "                           '\\\" -----> 双引号'\n",
    "                           '\\a -----> 响铃'\n",
    "                           '\\b -----> 退格(Backspace)'\n",
    "                           '\\e -----> 转义'\n",
    "                           '\\000 -----> 空'\n",
    "                           '\\n -----> 换行'\n",
    "                           '\\v -----> 纵向制表符'\n",
    "                           '\\t -----> 横向制表符'\n",
    "                           '\\r -----> 回车'\n",
    "                           '\\f -----> 换页'\n",
    "                           '\\other -----> 其它的字符以普通格式输出'},\n",
    "              '代码示例':{\n",
    "                        '17 / 3',\n",
    "                        '5.666666666666667    #返回结果',\n",
    "                        '可以运用它在计算机上做简单的加减乘除'}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_object={\n",
    "               '掌握程度':'90',\n",
    "               '定义':['python中一切数据都是对象',\n",
    "                       '对象可以有状态（属性或值）和行为（方法）',\n",
    "                       '4个内置数据结构可以保存任何对象集合：列表、元组、字典和集合'] \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 内置数据结构\n",
    "> 列表、元组、字典和集合"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_list={\n",
    "                       '掌握程度':'80',\n",
    "                       '参考网页':'https://www.runoob.com/python/python-lists.html',\n",
    "            '列表':{\n",
    "                    '定义':['有序的可变对象集合',\n",
    "                           '列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。',\n",
    "                           '列表的数据项不需要具有相同的类型'],\n",
    "                     '代码实例':{\"列表的创建\":\"list1 = ['physics', 'chemistry', 1997, 2000]\",\n",
    "                                 '列表的访问':'print \"list1[1:5]: \"',\n",
    "                                 \"列表的修改\":{\"1.增加\":\"list1.append('Google') #若无添加具体位置要求，append默认增添到最后一位\",\n",
    "                                               \"2.删除\":[\"del list1[2]\",\n",
    "                                                         'list1.pop(1)',\n",
    "                                                         'list1.remove(\"2000\"),#前三个都是删除指定位置元素',\n",
    "                                                         'list1.clear() #整个删除'],\n",
    "                                               '3.插入':'list1.insert(1,\"地球之盐\")',\n",
    "                                               '4.计算次数':'list.count(obj)',\n",
    "                                               '5.反向':'list.reverse()',\n",
    "                                               '6.函数':['cmp(list1, list2)--->比较两个列表的元素',\n",
    "                                                       'len(list)--->列表元素个数',\n",
    "                                                       'max(list)--->返回列表元素最大值',\n",
    "                                                       'min(list)--->返回列表元素最小值',\n",
    "                                                       'list(seq)--->将元组转换为列表']}\n",
    "                            }\n",
    "            }\n",
    "             \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 元组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_tuple={\n",
    "              '掌握程度':'75',\n",
    "              '参考网页':'https://www.runoob.com/python/python-tuples.html',\n",
    "              '定义':['Python的元组与列表类似，不同之处在于元组的元素不能修改。',\n",
    "                      '元组使用小括号，列表使用方括号。'],\n",
    "              '代码实例':{'1.创建':'tup1 = (50,)',\n",
    "                          '2.访问':'print \"tup1[0]: \", tup1[0]',\n",
    "                          '3.连接组合':['tup1 = (12, 34.56)',\n",
    "                                        \"tup2 = ('abc', 'xyz')\",\n",
    "                                        'tup3 = tup1 + tup2',\n",
    "                                        'print tup3',\n",
    "                                        '元组不允许修改元素，但是我们能够用连接不同元组的方式进行元组内元素的增加'],\n",
    "                          '4.删除':['元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组',\n",
    "                                    '代码为：del tup'],\n",
    "                          '5.函数':['1.cmp(tuple1, tuple2)--->比较两个元组元素。',\n",
    "                                    '2.len(tuple)--->计算元组元素个数。',\n",
    "                                    '3.max(tuple)--->返回元组中元素最大值。',\n",
    "                                    '4.min(tuple)--->返回元组中元素最小值。',\n",
    "                                    '5.tuple(seq)--->将列表转换为元组。']}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 字典"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_dict={\n",
    "             '掌握程度':'80',\n",
    "             '参考网页':'https://www.runoob.com/python/python-dictionary.html',\n",
    "             '定义':['字典是另一种可变容器模型，且可存储任意类型对象。',\n",
    "                     '字典的每个键值 key=>value 对用冒号 : 分割',\n",
    "                     '每个键值对之间用逗号 , 分割',\n",
    "                     '整个字典包括在花括号 {} 中'],\n",
    "             '注意事项':['1.键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。',\n",
    "                         '2.值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。',\n",
    "                         '3.如果用字典里没有的键访问数据，会输出错误',\n",
    "                         '4.不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住',],\n",
    "             '代码实例':{\"1.创建\":\"dict={'Name': 'Zara', 'Age': 7, 'Class': 'First'}\",\n",
    "                         \"2.访问\":\"dict['Alice']\",\n",
    "                         \"3.修改\":\"dict['Age'] = 8\",\n",
    "                         \"4.增加\":\"dict['School'] = '菜鸟教程'\",\n",
    "                         \"5.删除\":[\"del dict['Name'] ----> #删除键 'Name'\",\n",
    "                                   \"dict.clear() ----> #清空字典\",\n",
    "                                   \"del dict ----> #删除字典\",\n",
    "                                   \"popitem() ----> #随机返回并删除字典中的最后一对键和值。\"],\n",
    "                         \"6.复制\":\"dict.copy()\",\n",
    "                         \"7.查找\":\"dict.get(key, default=None)--->若在，返回值，不在则返回none\",\n",
    "                         \"8.遍历\":\"dict.items()\"\n",
    "                    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 集合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_set={\n",
    "            '掌握程度':'75',\n",
    "            '参考网页':'https://www.runoob.com/python3/python3-set.html',\n",
    "            '定义':'集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合',\n",
    "            '注意事项':'创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。',\n",
    "            '代码实例':{\"1.创建\":[\"basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}\",\n",
    "                                  \"basket2 = {'cherry'}\"],\n",
    "                        \"2.增加\":\"basket.add('tomato')\",\n",
    "                        \"3.删除\":[\"basket.clear() ----> 删除所有元素\",\n",
    "                                  \"basket.pop() ----> 随机删除一个元素\",\n",
    "                                  \"basket.discard('apple') ----> 删除集合内某个元素\",\n",
    "                                  \"basket.remove('apple') ----> 删除集合内某个元素\"],\n",
    "                        \"4.复制\":\"x=basket.copy()\",\n",
    "                        \"5.返回多集合差值\":\"z=basket.different.(basket2)\",\n",
    "                        \"6.返回多集合交值\":\"z=basket.intersection.(basket2)\",\n",
    "                        \"7.返回多集合并值\":\"z=basket.union.(basket2)\",\n",
    "                        \"8.更新整个集合的内容\":\"basket.update(basket2)\"\n",
    "                   }\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 日期和时间\n",
    ">1.datetime模块  \n",
    ">2.time模块  \n",
    ">3.calendar模块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_date_time={\n",
    "    'datetime':{'掌握程度':'80',\n",
    "                '参考页面':'python教材p10-11',\n",
    "                '代码示例':['import datetime',\n",
    "                            'datetime.date.today()',\n",
    "                            '>>datetime.date(2020, 9, 20)',\n",
    "                            'datetime.date.isoformat(datetime.date.today())',\n",
    "                            \">>'2020-09-20'\"]\n",
    "               },\n",
    "    'Time':{'掌握程度':'75',\n",
    "            '定义':'time 模块下有很多函数可以转换常见日期格式',\n",
    "            '参考网页':'https://www.runoob.com/python3/python3-date-time.html',\n",
    "            '注意事项':{'1.':'使用前记得首先要import time',\n",
    "                        '2.python中时间日期格式化符号':['%y ---> 两位数的年份表示（00-99）',\n",
    "                                                        '%Y ---> 四位数的年份表示（000-9999）',\n",
    "                                                        '%m ---> 月份（01-12）',\n",
    "                                                        '%d ---> 月内中的一天（0-31）',\n",
    "                                                        '%H ---> 24小时制小时数（0-23）',\n",
    "                                                        '%I ---> 12小时制小时数（01-12）',\n",
    "                                                        '%M ---> 分钟数（00=59）',\n",
    "                                                        '%S ---> 秒（00-59）',\n",
    "                                                        '%a ---> 本地简化星期名称',\n",
    "                                                        '%A ---> 本地完整星期名称',\n",
    "                                                        '%b ---> 本地简化的月份名称',\n",
    "                                                        '%B ---> 本地完整的月份名称',\n",
    "                                                        '%c ---> 本地相应的日期表示和时间表示',\n",
    "                                                        '%j ---> 年内的一天（001-366）',\n",
    "                                                        '%p ---> 本地A.M.或P.M.的等价符',\n",
    "                                                        '%U ---> 一年中的星期数（00-53）星期天为星期的开始',\n",
    "                                                        '%w ---> 星期（0-6），星期天为星期的开始',\n",
    "                                                        '%W ---> 一年中的星期数（00-53）星期一为星期的开始',\n",
    "                                                        '%x ---> 本地相应的日期表示',\n",
    "                                                        '%X ---> 本地相应的时间表示',\n",
    "                                                        '%Z ---> 当前时区的名称',\n",
    "                                                        '%% ---> %号本身']\n",
    "                   },\n",
    "            '代码实例':{'1.获取当前时间':'localtime = time.localtime(time.time())',\n",
    "                        '2.获取格式化的时间':'localtime = time.asctime( time.localtime(time.time()) )',\n",
    "                        '3.格式化日期':['格式：time.strftime(format[, t])',\n",
    "                                        '例子参考：',\n",
    "                                        '1.格式化成2016-03-20 11:45:39形式',\n",
    "                                        'print (time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime()))',\n",
    "                                        '2.格式化成Sat Mar 28 22:24:24 2016形式',\n",
    "                                        'print (time.strftime(\"%a %b %d %H:%M:%S %Y\", time.localtime()))',\n",
    "                                        '3.将格式字符串转换为时间戳',\n",
    "                                        'a = \"Sat Mar 28 22:24:24 2016\"',\n",
    "                                        'print (time.mktime(time.strptime(a,\"%a %b %d %H:%M:%S %Y\")))']\n",
    "                   }\n",
    "           },\n",
    "    'Calendar':{'掌握程度':'65',\n",
    "                '参考网页':'https://www.runoob.com/python3/python3-date-time.html',\n",
    "                '定义':'有很广泛的方法用来处理年历和月历，例如打印某月的月历',\n",
    "                '注意事项':'与time模块一样，使用前记得首先要import calendar',\n",
    "                '代码示例':{'1.获取某月日历':'cal = calendar.month(2016, 1)',\n",
    "                            '2.获取多行字符串格式的year年年历':'calendar.calendar(year,w=2,l=1,c=6)',\n",
    "                            '3.返回当前每周起始日期':['calendar.firstweekday( )',\n",
    "                                                      '#默认情况下首次载入caendar模块时返回0，即星期一。'],\n",
    "                            '4.判断是否闰年':'calendar.isleap(year)'}\n",
    "                 }\n",
    "     }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 函数  \n",
    ">1.函数的定义  \n",
    ">2.形参和实参  \n",
    ">3.返回值  \n",
    ">4.注释  \n",
    ">5.递归  \n",
    ">6.局部变量   \n",
    ">7.全局变量  \n",
    ">8.函数的调用  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_function={'掌握程度':'65',\n",
    "                 '参考网页':'https://www.cnblogs.com/xuzhichao/p/11570285.html',\n",
    "                 '定义':{'1.函数':['是逻辑结构化和过程化的一种编程方法,是命名的代码块。',\n",
    "                                   'def关键字用来命名函数，函数代码在def关键字下（相对于def关键字）缩进',\n",
    "                                   '函数可以接受任意多个命名参数',\n",
    "                                   'return语句允许函数返回任意值（也可以不反回任何值）',\n",
    "                                   '函数注解可以用来描述函数参数的类型'],\n",
    "                         '2.形参和实参':['1.形参不是实际存在的，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参',\n",
    "                                         '2.实参调用函数时传递给函数的参数，可以是常量、变量，表达式，函数，传给形参',\n",
    "                                         '3.区别：形参是虚拟的，不占用空间，形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传递单向，实参传给形参，不能倒过来'],\n",
    "                         '3.返回值':['函数返回的值被称为函数的返回值',\n",
    "                                     '返回值能将你程序的大部分繁重工作移到函数中去完成，从而简化主程序。'],\n",
    "                         '4.注释':'注释非常重要，是你对函数功能的描述也是别人在调用你的函数时的一份说明书，所以必须认真对待。',\n",
    "                         '5.递归':{'递归特性':['1.必须有一个明确的结束条件',\n",
    "                                                '2.每次进入更深一层递归时，问题规模相比上次递归应有所减少。',\n",
    "                                                '3.递归效率不高，递归次数过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会多加一层栈帧，每当函数返回，栈就会减少一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。）'],\n",
    "                                   '代码实例':['def calc(n):',\n",
    "                                              'print(n)',\n",
    "                                              'if int(n/2) == 0:',\n",
    "                                              'return n',\n",
    "                                              'return calc(int(n/2))']},\n",
    "                         '6.局部变量':{'定义':'在函数内部定义的变量，它的作用域也仅限于函数内部，出了函数就不能使用了，我们将这样的变量称为局部变量',\n",
    "                                       '代码实例':['def demo():',\n",
    "                                                   'add = \"http://c.biancheng.net/python/\"',\n",
    "                                                   'print(\"函数内部 add =\",add)',\n",
    "                                                   'demo()',\n",
    "                                                   'print(\"函数外部 add =\",add)']},\n",
    "                         '7.全局变量':{'定义':['1.所有函数的外部定义变量，这样的变量称为全局变量（Global Variable）',\n",
    "                                                '2.和局部变量不同，全局变量的默认作用域是整个程序，即全局变量既可以在各个函数的外部使用，也可以在各函数内部使用。',\n",
    "                                                '3.在函数体内定义全局变量。即使用 global 关键字对变量进行修饰后，该变量就会变为全局变量。'],\n",
    "                                        '注意':'在使用 global 关键字修饰变量名时，不能直接给变量赋初值，否则会引发语法错误。',\n",
    "                                        '代码示例':['def text():',\n",
    "                                                    'global add',\n",
    "                                                    'add= \"http://c.biancheng.net/java/\"',\n",
    "                                                    'print(\"函数体内访问：\",add)',\n",
    "                                                    'text()',\n",
    "                                                    \"print('函数体外访问：',add)\"]},\n",
    "                 '注意事项':['1.参数分关键字参数和位置参数，在定义函数和使用函数时，两者可以同时存在，但一定要确保位置参数在关键字参数前面。',\n",
    "                             '2.函数一定不会报错，哪怕你的语法有错，参数没定义。 ---原因---> 函数只有在被调用时才会有真正意义的运行'\n",
    "                             '3.函数内也是可以引用函数的，大胆地去用吧~'],\n",
    "                 '定义格式':['def fib(n):',\n",
    "                            '\"\"\"Print a Fibonacci series up to n.\"\"\"',\n",
    "                            'a, b = 0, 1',\n",
    "                            'while a < n:',\n",
    "                            \"return(a, end=' ')\",\n",
    "                            'a, b = b, a+b',\n",
    "                            'print()',\n",
    "                            '注释:',\n",
    "                                  'def:定义函数的关键字',\n",
    "                                  'flb：函数名',\n",
    "                                  '(n)：定义函数的参数',\n",
    "                                  '\"\"\"\"\"\"：文档描述',\n",
    "                                  '代码块：',\n",
    "                                  '     a, b = 0, 1',\n",
    "                                  '     while a < n:',\n",
    "                                  \"        return(a, end=' ')\",\n",
    "                                  '         a, b = b, a+b',\n",
    "                                  '     print()'],\n",
    "                 '方法':{'1.传入多个参数':['*args',\n",
    "                                           '实例：def make_pizza(*toppings): '],\n",
    "                         '2.把关键字参数转化成字典':'def infos(**kwargs):',\n",
    "                         '3.导入模块':['1.整个模块：import xx #xx是函数名',\n",
    "                                       '2.模块内某个函数：form 模块名 import 函数名',\n",
    "                                       '3.模块内的所有函数：from 模块名 import*']},\n",
    "                 '优势':['1.通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上',\n",
    "                         '2.可以让不同的程序中重用函数',\n",
    "                         '3.可与其他程序员共享这些文件而不是整个程序',\n",
    "                         '4.知道如何导入函数能让你使用其他程序员编写的函数库',\n",
    "                         '5.节省代码，重复利用',\n",
    "                         '6.可以给小白用']\n",
    "    \n",
    "}\n",
    "                }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "307.2px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
